79 research outputs found
Managing LTL properties in Event-B refinement
Refinement in Event-B supports the development of systems via proof based
step-wise refinement of events. This refinement approach ensures safety
properties are preserved, but additional reasoning is required in order to
establish liveness and fairness properties.
In this paper we present results which allow a closer integration of two
formal methods, Event-B and linear temporal logic. In particular we show how a
class of temporal logic properties can carry through a refinement chain of
machines. Refinement steps can include introduction of new events, event
renaming and event splitting. We also identify a general liveness property that
holds for the events of the initial system of a refinement chain. The approach
will aid developers in enabling them to verify linear temporal logic properties
at early stages of a development, knowing they will be preserved at later
stages. We illustrate the results via a simple case study
Lifting the Reasoning Level in Generic Weak Memory Verification (Extended Version)
Weak memory models specify the semantics of concurrent programs on multi-core
architectures. Reasoning techniques for weak memory models are often
specialized to one fixed model and verification results are hence not
transferable to other memory models. A recent proposal of a generic
verification technique based on axioms on program behaviour expressed via
weakest preconditions aims at overcoming this specialization to dedicated
models. Due to the usage of weakest preconditions, reasoning however takes
place on a very low level requiring the application of numerous axioms for
deriving program properties, even for a single statement. In this paper, we
lift reasoning in this generic verification approach to a more abstract level.
Based on a view-based assertion language, we provide a number of novel proof
rules for directly reasoning on the level of program constructs. We prove
soundness of our proof rules and exemplify them on the write-to-read causality
(WRC) litmus test. A comparison to the axiom-based low-level proof reveals a
significant reduction in the number of required proof steps
A CSP Account of Event-B Refinement
Event-B provides a flexible framework for stepwise system development via
refinement. The framework supports steps for (a) refining events (one-by-one),
(b) splitting events (one-by-many), and (c) introducing new events. In each of
the steps events can moreover possibly be anticipated or convergent. All such
steps are accompanied with precise proof obligations. Still, it remains unclear
what the exact relationship - in terms of a behaviour-oriented semantics -
between an Event-B machine and its refinement is. In this paper, we give a CSP
account of Event-B refinement, with a treatment for the first time of splitting
events and of anticipated events. To this end, we define a CSP semantics for
Event-B and show how the different forms of Event-B refinement can be captured
as CSP refinement.Comment: In Proceedings Refine 2011, arXiv:1106.348
- ā¦